<?php
$i18n = new I18n();

//翻译文字
function __($string) {
	global $i18n;
	if ( func_num_args() == 1 ) {
		return $i18n->translate($string);
	} else {
		$args = func_get_args();
		array_shift($args);
		return vsprintf($i18n->translate($string), $args);
	}
}

//翻译文字并输出
function _e() {
	$args = func_get_args();
	echo call_user_func_array('__', $args);
}

//翻译复数形式
function _n($single, $plural, $number) {
	global $i18n;
	return $i18n->ngettext($single, $plural, $number);
}

//翻译复数形式并输出
function _en() {
	$args = func_get_args();
	echo call_user_func_array('_n', $args);
}

class I18n {
	var $_handle = array();
	
	//添加语言文件
	function add_lang($file) {
		$this->_handle[] = new gettext_reader($file);
	}
	
	//翻译
	function translate($string) {
		foreach ( $this->_handle as $handle ) {
			$string = $handle->translate($num);
			if ( -1 != $num ) {
				break;
			}
		}
		return $string;
	}
	
	//复数形式的翻译
	function ngettext($single, $plural, $number) {
		foreach ( $this->_handle as $handle ) {
			$string = $handle->ngettext($single, $plural, $number, $num);
			if ( -1 == $num ) {
				break;
			}
		}
		return $string;
	}
}

/*
Copyright (c) 2003, 2009 Danilo Segan <danilo@kvota.net>.
Copyright (c) 2005 Nico Kaiser <nico@siriux.net>

This file is part of PHP-gettext.

PHP-gettext is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

PHP-gettext is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with PHP-gettext; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
class gettext_reader {
	//public:
	var $error = 0; // public variable that holds error code (0 if no error)
	
	//private:
	var $BYTEORDER = 0;        // 0: low endian, 1: big endian
	var $STREAM = NULL;
	var $short_circuit = false;
	var $enable_cache = false;
	var $originals = NULL;      // offset of original table
	var $translations = NULL;    // offset of translation table
	var $pluralheader = NULL;    // cache header field for plural forms
	var $total = 0;          // total string count
	var $table_originals = NULL;  // table for original strings (offsets)
	var $table_translations = NULL;  // table for translated strings (offsets)
	var $cache_translations = NULL;  // original -> translation mapping


	/* Methods */
	
	/**
	* Constructor
	*
	* @param object Reader the StreamReader object
	* @param boolean enable_cache Enable or disable caching of strings (default on)
	*/
	function gettext_reader($file, $enable_cache = true) {
		// If there isn't a StreamReader, turn on short circuit mode.
		if ( empty($file) || !file_exists($file) ) {
			$this->short_circuit = true;
			return;
		}
		// Caching can be turned off
		$this->enable_cache = $enable_cache;
	
		$MAGIC1 = "\x95\x04\x12\xde";
		$MAGIC2 = "\xde\x12\x04\x95";
	
		$this->STREAM = fopen($file);
		$magic = fread($this->STREAM, 4);
		if ($magic == $MAGIC1) {
			$this->BYTEORDER = 1;
		} elseif ($magic == $MAGIC2) {
			$this->BYTEORDER = 0;
		} else {
			$this->error = 1; // not MO file
			return false;
		}
	
		// FIXME: Do we care about revision? We should.
		$revision = $this->readint();
		
		$this->total = $this->readint();
		$this->originals = $this->readint();
		$this->translations = $this->readint();
	}
	
	/**
	* Reads a 32bit Integer from the Stream
	*
	* @access private
	* @return Integer from the Stream
	*/
	function readint() {
		if ($this->BYTEORDER == 0) {
			// low endian
			$input=unpack('V', fread($this->STREAM,4));
			return array_shift($input);
		} else {
			// big endian
			$input=unpack('N', fread($this->STREAM,4));
			return array_shift($input);
		}
	}

	/**
	* Reads an array of Integers from the Stream
	*
	* @param int count How many elements should be read
	* @return Array of Integers
	*/
	function readintarray($count) {
		if ($this->BYTEORDER == 0) {
			// low endian
			return unpack('V'.$count, fread($this->STREAM, 4 * $count));
		} else {
			// big endian
			return unpack('N'.$count, fread($this->STREAM, 4 * $count));
		}
	}

	/**
	* Loads the translation tables from the MO file into the cache
	* If caching is enabled, also loads all strings into a cache
	* to speed up translation lookups
	*
	* @access private
	*/
	function load_tables() {
		if ( is_array($this->cache_translations) && is_array($this->table_originals) && is_array($this->table_translations) )
			return;
	
		/* get original and translations tables */
		if (!is_array($this->table_originals)) {
			fseek($this->STREAM, $this->originals);
			$this->table_originals = $this->readintarray($this->total * 2);
		}
		if (!is_array($this->table_translations)) {
			fseek($this->STREAM, $this->translations);
			$this->table_translations = $this->readintarray($this->total * 2);
		}
	
		if ($this->enable_cache) {
			$this->cache_translations = array ();
			/* read all strings in the cache */
			for ($i = 0; $i < $this->total; $i++) {
				fseek($this->STREAM, $this->table_originals[$i * 2 + 2]);
				$original = fread($this->STREAM, $this->table_originals[$i * 2 + 1]);
				fseek($this->STREAM, $this->table_translations[$i * 2 + 2]);
				$translation = fread($this->STREAM, $this->table_translations[$i * 2 + 1]);
				$this->cache_translations[$original] = $translation;
			}
		}
	}

	/**
	* Returns a string from the "originals" table
	*
	* @access private
	* @param int num Offset number of original string
	* @return string Requested string if found, otherwise ''
	*/
	function get_original_string($num) {
		$length = $this->table_originals[$num * 2 + 1];
		$offset = $this->table_originals[$num * 2 + 2];
		if (! $length)
			return '';
		fseek($this->STREAM, $offset);
		$data = fread($this->STREAM, $length);
		return (string)$data;
	}

	/**
	* Returns a string from the "translations" table
	*
	* @access private
	* @param int num Offset number of original string
	* @return string Requested string if found, otherwise ''
	*/
	function get_translation_string($num) {
		$length = $this->table_translations[$num * 2 + 1];
		$offset = $this->table_translations[$num * 2 + 2];
		if (! $length)
			return '';
		fseek($this->STREAM, $offset);
		$data = fread($this->STREAM, $length);
		return (string)$data;
	}

	/**
	* Binary search for string
	*
	* @access private
	* @param string string
	* @param int start (internally used in recursive function)
	* @param int end (internally used in recursive function)
	* @return int string number (offset in originals table)
	*/
	function find_string($string, $start = -1, $end = -1) {
		if (($start == -1) or ($end == -1)) {
			// find_string is called with only one parameter, set start end end
			$start = 0;
			$end = $this->total;
		}
		if (abs($start - $end) <= 1) {
			// We're done, now we either found the string, or it doesn't exist
			$txt = $this->get_original_string($start);
			if ($string == $txt)
				return $start;
			else
				return -1;
		} else if ($start > $end) {
			// start > end -> turn around and start over
			return $this->find_string($string, $end, $start);
		} else {
			// Divide table in two parts
			$half = (int)(($start + $end) / 2);
			$cmp = strcmp($string, $this->get_original_string($half));
			if ($cmp == 0)
				// string is exactly in the middle => return it
				return $half;
			else if ($cmp < 0)
				// The string is in the upper half
				return $this->find_string($string, $start, $half);
			else
				// The string is in the lower half
			return $this->find_string($string, $half, $end);
		}
	}

	/**
	* Translates a string
	*
	* @access public
	* @param string string to be translated
	* @return string translated string (or original, if not found)
	*/
	function translate($string, &$num) {
		if ($this->short_circuit)
			return $string;
		$this->load_tables();

		if ($this->enable_cache) {
			// Caching enabled, get translated string from cache
			if (array_key_exists($string, $this->cache_translations))
				return $this->cache_translations[$string];
			else
				return $string;
		} else {
			// Caching not enabled, try to find string
			$num = $this->find_string($string);
			if ($num == -1)
				return $string;
			else
				return $this->get_translation_string($num);
		}
	}

	/**
	* Sanitize plural form expression for use in PHP eval call.
	*
	* @access private
	* @return string sanitized plural form expression
	*/
	function sanitize_plural_expression($expr) {
		// Get rid of disallowed characters.
		$expr = preg_replace('@[^a-zA-Z0-9_:;\(\)\?\|\&=!<>+*/\%-]@', '', $expr);

		// Add parenthesis for tertiary '?' operator.
		$expr .= ';';
		$res = '';
		$p = 0;
		for ($i = 0; $i < strlen($expr); $i++) {
			$ch = $expr[$i];
			switch ($ch) {
				case '?':
					$res .= ' ? (';
					$p++;
					break;
				case ':':
					$res .= ') : (';
					break;
				case ';':
					$res .= str_repeat( ')', $p) . ';';
					$p = 0;
					break;
				default:
					$res .= $ch;
			}
		}
		return $res;
	}

	/**
	* Parse full PO header and extract only plural forms line.
	*
	* @access private
	* @return string verbatim plural form header field
	*/
	function extract_plural_forms_header_from_po_header($header) {
		if (preg_match("/(^|\n)plural-forms: ([^\n]*)\n/i", $header, $regs))
			$expr = $regs[2];
		else
			$expr = "nplurals=2; plural=n == 1 ? 0 : 1;";
		return $expr;
	}

	/**
	* Get possible plural forms from MO header
	*
	* @access private
	* @return string plural form header
	*/
	function get_plural_forms() {
		// lets assume message number 0 is header
		// this is true, right?
		$this->load_tables();

		// cache header field for plural forms
		if (! is_string($this->pluralheader)) {
			if ($this->enable_cache) {
				$header = $this->cache_translations[""];
			} else {
				$header = $this->get_translation_string(0);
			}
			$expr = $this->extract_plural_forms_header_from_po_header($header);
			$this->pluralheader = $this->sanitize_plural_expression($expr);
		}
		return $this->pluralheader;
	}

	/**
	* Detects which plural form to take
	*
	* @access private
	* @param n count
	* @return int array index of the right plural form
	*/
	function select_string($n) {
		$string = $this->get_plural_forms();
		$string = str_replace('nplurals',"\$total",$string);
		$string = str_replace("n",$n,$string);
		$string = str_replace('plural',"\$plural",$string);

		$total = 0;
		$plural = 0;

		eval("$string");
		if ($plural >= $total) $plural = $total - 1;
		return $plural;
	}

	/**
	* Plural version of gettext
	*
	* @access public
	* @param string single
	* @param string plural
	* @param string number
	* @return translated plural form
	*/
	function ngettext($single, $plural, $number, & $num) {
		if ($this->short_circuit) {
			if ($number != 1) {
				return $plural;
			} else {
				return $single;
			}
		}

		// find out the appropriate form
		$select = $this->select_string($number);

		// this should contains all strings separated by NULLs
		$key = $single . chr(0) . $plural;

		if ($this->enable_cache) {
			if (! array_key_exists($key, $this->cache_translations)) {
				return ($number != 1) ? $plural : $single;
			} else {
				$result = $this->cache_translations[$key];
				$list = explode(chr(0), $result);
				return $list[$select];
			}
		} else {
			$num = $this->find_string($key);
			if ($num == -1) {
				return ($number != 1) ? $plural : $single;
			} else {
				$result = $this->get_translation_string($num);
				$list = explode(chr(0), $result);
				return $list[$select];
			}
		}
	}

	function pgettext($context, $msgid) {
		$key = $context . chr(4) . $msgid;
		return $this->translate($key);
	}

	function npgettext($context, $singular, $plural, $number) {
		$singular = $context . chr(4) . $singular;
		return $this->ngettext($singular, $plural, $number);
	}
}
?>